// 获取authController中的用户数据（在实际应用中应通过依赖注入或模块导出）
const authController = require('./authController');
const { User, Favorite } = require('../models');

// 获取所有用户
exports.getAllUsers = async (req, res) => {
  try {
    const users = await User.findAll({
      attributes: { exclude: ['password'] }
    });

    res.status(200).json({
      status: 'success',
      results: users.length,
      data: {
        users
      }
    });
  } catch (error) {
    res.status(500).json({
      status: 'error',
      message: error.message
    });
  }
};

// 获取单个用户
exports.getUser = async (req, res) => {
  try {
    const user = await User.findByPk(req.params.id, {
      attributes: { exclude: ['password'] }
    });

    if (!user) {
      return res.status(404).json({
        status: 'fail',
        message: '未找到此ID的用户'
      });
    }

    res.status(200).json({
      status: 'success',
      data: {
        user
      }
    });
  } catch (error) {
    res.status(500).json({
      status: 'error',
      message: error.message
    });
  }
};

// 获取当前用户信息
exports.getMe = (req, res, next) => {
  req.params.id = req.user.id;
  next();
};

// 更新当前用户信息
exports.updateMe = async (req, res) => {
  try {
    // 1) 不允许密码更新
    if (req.body.password) {
      return res.status(400).json({
        status: 'fail',
        message: '此路由不用于密码更新。请使用 /updatePassword'
      });
    }

    // 2) 过滤掉不允许更新的字段
    const filteredBody = filterObj(req.body, 'username', 'email');

    // 3) 更新用户文档
    const user = await User.findByPk(req.user.id);
    
    if (!user) {
      return res.status(404).json({
        status: 'fail',
        message: '未找到用户'
      });
    }
    
    await user.update(filteredBody);

    res.status(200).json({
      status: 'success',
      data: {
        user: {
          id: user.id,
          username: user.username,
          email: user.email,
          role: user.role,
          createdAt: user.createdAt,
          updatedAt: user.updatedAt
        }
      }
    });
  } catch (error) {
    res.status(400).json({
      status: 'fail',
      message: error.message
    });
  }
};

// 获取当前用户
exports.getCurrentUser = async (req, res) => {
  try {
    // 检查是否已登录
    if (!req.session.userId) {
      return res.status(401).json({
        status: 'fail',
        message: '请先登录'
      });
    }

    // 从数据库中获取用户信息
    const user = await User.findByPk(req.session.userId, {
      attributes: { exclude: ['password'] }
    });
    
    if (!user) {
      return res.status(404).json({
        status: 'fail',
        message: '找不到用户'
      });
    }

    res.status(200).json({
      status: 'success',
      data: {
        user: user
      }
    });
  } catch (error) {
    console.error('获取当前用户错误:', error);
    res.status(500).json({
      status: 'error',
      message: error.message
    });
  }
};

// 更新用户信息
exports.updateUser = async (req, res) => {
  try {
    // 检查是否已登录
    if (!req.session.userId) {
      return res.status(401).json({
        status: 'fail',
        message: '请先登录'
      });
    }

    // 获取用户数据
    const user = await User.findByPk(req.session.userId);
    
    if (!user) {
      return res.status(404).json({
        status: 'fail',
        message: '找不到用户'
      });
    }

    // 更新用户信息
    const { username, email, password } = req.body;
    
    if (username) user.username = username;
    if (email) user.email = email;
    if (password) user.password = password;

    // 保存更新
    await user.save();

    // 同时更新内存中的用户信息（兼容旧代码）
    const userMap = authController.users || new Map();
    const memoryUser = userMap.get(req.session.userId.toString());
    if (memoryUser) {
      memoryUser.username = user.username;
      memoryUser.email = user.email;
    }

    // 返回更新后的用户信息（不包含密码）
    const userWithoutPassword = await User.findByPk(req.session.userId, {
      attributes: { exclude: ['password'] }
    });

    res.status(200).json({
      status: 'success',
      data: {
        user: userWithoutPassword
      }
    });
  } catch (error) {
    console.error('更新用户信息错误:', error);
    res.status(500).json({
      status: 'error',
      message: error.message
    });
  }
};

// 获取收藏城市列表
exports.getFavorites = async (req, res) => {
  try {
    // 检查是否已登录
    if (!req.session.userId) {
      // 未登录用户返回空收藏列表，而不是401错误
      return res.status(200).json({
        status: 'success',
        data: {
          favorites: []
        }
      });
    }

    // 从数据库中获取收藏城市列表
    const favorites = await Favorite.findAll({
      where: { userId: req.session.userId },
      attributes: ['id', 'city', 'province', 'createdAt']
    });

    res.status(200).json({
      status: 'success',
      data: {
        favorites: favorites
      }
    });
  } catch (error) {
    console.error('获取收藏城市列表错误:', error);
    res.status(500).json({
      status: 'error',
      message: error.message
    });
  }
};

// 添加收藏城市
exports.addFavorite = async (req, res) => {
  try {
    const { city, province } = req.body;

    if (!city || !province) {
      return res.status(400).json({
        status: 'fail',
        message: '请提供城市和省份'
      });
    }

    // 用户ID从req.user中获取
    const userId = req.user.id;

    // 检查是否已收藏
    const existingFavorite = await Favorite.findOne({
      where: {
        userId,
        city,
        province
      }
    });

    if (existingFavorite) {
      return res.status(400).json({
        status: 'fail',
        message: '该城市已收藏'
      });
    }

    // 添加到收藏
    const favorite = await Favorite.create({
      userId,
      city,
      province
    });

    // 同时更新内存中的用户收藏列表（兼容旧代码）
    const userMap = authController.users || new Map();
    const user = userMap.get(userId.toString());
    if (user) {
      if (!user.favorites) {
        user.favorites = [];
      }
      user.favorites.push({
        id: favorite.id,
        city,
        province,
        createdAt: favorite.createdAt
      });
    }

    // 获取更新后的所有收藏
    const allFavorites = await Favorite.findAll({
      where: { userId },
      attributes: ['id', 'city', 'province', 'createdAt']
    });

    res.status(200).json({
      status: 'success',
      message: '收藏城市成功',
      data: {
        favorites: allFavorites
      }
    });
  } catch (error) {
    console.error('添加收藏城市错误:', error);
    res.status(500).json({
      status: 'error',
      message: error.message
    });
  }
};

// 移除收藏城市
exports.removeFavorite = async (req, res) => {
  try {
    const { city, province } = req.body;

    if (!city || !province) {
      return res.status(400).json({
        status: 'fail',
        message: '请提供城市和省份'
      });
    }

    // 用户ID从req.user中获取
    const userId = req.user.id;

    // 查找并删除收藏
    const result = await Favorite.destroy({
      where: {
        userId,
        city,
        province
      }
    });

    if (result === 0) {
      return res.status(404).json({
        status: 'fail',
        message: '未找到该收藏城市'
      });
    }

    // 同时更新内存中的用户收藏列表（兼容旧代码）
    const userMap = authController.users || new Map();
    const user = userMap.get(userId.toString());
    if (user && user.favorites) {
      user.favorites = user.favorites.filter(
        f => !(f.city === city && f.province === province)
      );
    }

    // 获取更新后的所有收藏
    const allFavorites = await Favorite.findAll({
      where: { userId },
      attributes: ['id', 'city', 'province', 'createdAt']
    });

    res.status(200).json({
      status: 'success',
      message: '移除收藏城市成功',
      data: {
        favorites: allFavorites
      }
    });
  } catch (error) {
    console.error('移除收藏城市错误:', error);
    res.status(500).json({
      status: 'error',
      message: error.message
    });
  }
};

// 辅助函数：过滤对象中的字段
const filterObj = (obj, ...allowedFields) => {
  const newObj = {};
  Object.keys(obj).forEach(el => {
    if (allowedFields.includes(el)) newObj[el] = obj[el];
  });
  return newObj;
}; 